/*
 * operacionesIO.c
 *
 *  Created on: 22/09/2011
 *      Author: utn_so
 */

#include "operacionesIO.h"
#include <stdio.h>
#include "log.h"

extern FILE *volumenFile;

int32_t AbrirArchivoFd (char **pathFatFile)
{
	int32_t fd;

	fd = open((*pathFatFile), O_RDWR);

	if( fd == -1 ){
		perror("");
	}

	fdatasync(fd);
	posix_fadvise(fd, 0,0,POSIX_FADV_RANDOM);

	return fd;
}


FILE* AbrirArchivoDiscoStream(int32_t fd)
{
	FILE *File = fdopen(fd,"r+b");
	return File;
}


int32_t LeerSector (stPedido *pedido, char **pathFatFile)
{
	fseek(volumenFile,pedido->sector*512,SEEK_SET);
	fread_unlocked (pedido->contenido, 1, 512, volumenFile);

	return 1;
}


int32_t EscribirSector (stPedido *pedido, char **pathFatFile)
{

	fseek(volumenFile,pedido->sector*512,SEEK_SET);
	fwrite_unlocked(pedido->contenido,1,512,volumenFile);
	return 1;
}

int32_t ejecutarPedido (char **algoritmo,char **pathFatFile,
						stNodoPedido **listaPedidos,chs datosConfig,
						chs **posicionActual,int32_t delayLectura,
						int32_t delayEscritura,int32_t socketRaid,
						stNodoSincro **listaSincro, long *contSincro,
						int32_t estoySincronizado, int32_t *contadorEjecutar,
						int32_t *agregadosEjecutar,stNodoPedido **listaEjecutar
						, int32_t *sentidoGiro, sem_t *semaforoContador,
						int32_t hayqueloguear)
{
	stPedido *pedido;
	char *paq;
	int32_t payloadlength,socketTrace;
	char *mensaje;
	char *conversion ;
	char *auxiliar; //= (char*)malloc(40);TODO



	if(strncmp((*algoritmo),"SSTF",4) == 0)
	{
		if (estoySincronizado > 0)
		{
			pedido = proximoPedidoSSTFSincro(listaPedidos,posicionActual,
					datosConfig,listaSincro);
		}
		else
		{
			pedido = proximoPedidoSSTF(listaPedidos,posicionActual,datosConfig);
		}

		if(hayqueloguear == 1)
		{
			loguearSSTF (pedido,listaPedidos,datosConfig,posicionActual);
		}

	}
	else
	{

		pedido = proximoPedidoNSTEP(listaEjecutar,posicionActual,datosConfig,sentidoGiro);

		if(hayqueloguear == 1)
		{
			loguearNSTEPSCAN(pedido,listaEjecutar,datosConfig,posicionActual,
					sentidoGiro,listaPedidos);
		}

	}

	if(pedido->tipoOperacion == LEER)
	{
		if(delayLectura > 0 )
			sleep(delayLectura);
		LeerSector(pedido,pathFatFile);
		//printf("lei un pedido EJECUTAR %ld\n",pedido->sector);


		payloadlength = sizeof(stPedido);
		mensaje = malloc(payloadlength);
		memcpy(mensaje,pedido,sizeof(stPedido));

		paq = serializarNipc(LEER,mensaje,payloadlength);

		if (socketRaid > 0)
		{
			send(socketRaid,paq,sizeof(PAQUETE_NIPC_CABECERA) + payloadlength, 0);
		}
			else
		{
		send(pedido->socketPFS,paq,sizeof(PAQUETE_NIPC_CABECERA) + payloadlength, 0);
		}
		free(paq);
		free(mensaje);
/////////////////////////////////////////////
	}
	else if(pedido->tipoOperacion == SINCROLEER)
	{
		if(delayLectura > 0 )
			sleep(delayLectura);
		LeerSector(pedido,pathFatFile);

		int32_t resto = pedido->sector%5000;
		//if (resto == 0)
			//printf("lei un pedido %ld\n", pedido->sector);

		pedido->tipoOperacion = SINCROLEERRESPUESTA;

		payloadlength = sizeof(stPedido);
		mensaje = malloc(payloadlength);
		memcpy(mensaje,pedido,sizeof(stPedido));
		paq = serializarNipc(SINCROLEERRESPUESTA,mensaje,payloadlength);

		int nbytes=send(socketRaid,paq,sizeof(PAQUETE_NIPC_CABECERA) + payloadlength, 0);

		if(nbytes < (sizeof(PAQUETE_NIPC_CABECERA) + payloadlength))
		{
			printf("mande menos SINCROleerrta\n");
		}

		free(paq);
		free(mensaje);
/////////////////////////////////////////////
	}
	else if(pedido->tipoOperacion == ESCRIBIR)
	{
		if(delayEscritura > 0 )
			sleep(delayEscritura);
		EscribirSector(pedido,pathFatFile);

		//int32_t resto = pedido->sector%5000;
		//if (resto == 0)
			//printf("escribi un pedido \n");


		if (socketRaid > 0)
		{
			payloadlength = sizeof(stPedido);
			mensaje = malloc(payloadlength);
			memcpy(mensaje,pedido,sizeof(stPedido));

			paq = serializarNipc(ESCRIBIR,mensaje,payloadlength);
			send(socketRaid,paq,sizeof(PAQUETE_NIPC_CABECERA) + payloadlength, 0);

			free(paq);
			free(mensaje);
		}
		else
		{
			paq = serializarNipcSinPayload(PAYOK,0);
			send(pedido->socketPFS,paq,sizeof(PAQUETE_NIPC_CABECERA), 0);
			free(paq);
		}



/////////////////////////////////
	}else if(pedido->tipoOperacion == SINCROESCRIBIR)
	{
		sleep(delayEscritura);
		EscribirSector(pedido,pathFatFile);



		/*pedido->tipoOperacion = SINCROESCRIBIRRESPUESTA;

		payloadlength = sizeof(stPedido);
		mensaje = malloc(payloadlength);
		memcpy(mensaje,pedido,sizeof(stPedido));

		paq = serializarNipc(SINCROESCRIBIRRESPUESTA,mensaje,payloadlength);

		send(socketRaid,paq,sizeof(PAQUETE_NIPC_CABECERA) + payloadlength, 0);

		free(paq);
		free(mensaje); TODO: VER SI DESCOMENTAR*/
/////////////////////////////////

		//agrega sector a la lista sincro
		AgregarPedidoSincro(listaSincro,pedido->sector);
		*contSincro = *contSincro + 1;

		int32_t resto = pedido->sector%5000;
		//if (resto == 0)
			//printf("escribi un pedido %ld contsincro %ld\n", pedido->sector,*contSincro);

	}
	else if(pedido->tipoOperacion == TRACE)
	{
		auxiliar = malloc(40);
		chs *obt = malloc(sizeof(chs));
		obtenerCHSDif(pedido->sector,datosConfig,obt);
		int16_t secRecorridos =  (obt->s - (*posicionActual)->s);

		if( secRecorridos < 0)
		{
			secRecorridos =  secRecorridos + datosConfig.s;
		}

		float time = datosConfig.seekTime*secRecorridos;

		conversion = (char*)malloc(sizeof(char)*8000000);
		sprintf(conversion, "Posicion Actual: %u:%u \nSector Solicitado: %u:%u \nTiempo consumido: %f \nSectores Recorridos: ",
				(*posicionActual)->c,(*posicionActual)->s,obt->c,obt->s,time);

		char *auxiliar2 = (char*)malloc(5);
		int32_t i =(*posicionActual)->s + 1;
		for(;i<=datosConfig.s;i++)
		{
			 if(i == datosConfig.s)
			 {
				i = 0;
			 }
			 if( ((*posicionActual)->s == obt->s)|| (i == obt->s))
			 {
				 break;
			 }
			 sprintf(auxiliar2,"%u:%u,",obt->c,i);
			 strcat(conversion,auxiliar2);
		}
		sprintf(auxiliar2,"%u:%u",obt->c,obt->s);
		strcat(conversion,auxiliar2);
		strcat(conversion,"\n");

		socketTrace = pedido->socketPFS;

		free(obt);
	}

	obtenerCHSDif(pedido->sector,datosConfig,(*posicionActual));

	if ((*posicionActual)->s == (datosConfig.s - 1))
	{
		(*posicionActual)->s = 0;
	}
	else
	{
		(*posicionActual)->s++;
	}


	if(strncmp((*algoritmo),"SSTF",4) ==0)
	{
		sacarNodoListaPedidos(pedido,listaPedidos);
	}
	else
	{
		sacarNodoListaPedidos(pedido,listaEjecutar);
		*contadorEjecutar = *contadorEjecutar -1;


		if(*contadorEjecutar == 0 )
		{
			//rellenamos la de ejecutar

			*contadorEjecutar = 10;
			*agregadosEjecutar = 0;

			if((*listaPedidos) != NULL && (*listaPedidos)->info != NULL)
			{
				RellenarListaEjecucion(listaPedidos,listaEjecutar,agregadosEjecutar,estoySincronizado,listaSincro,semaforoContador);
			}

		}
		//AGREGADO EN EL LAB
		/*else if(((*listaEjecutar)==NULL || (*listaEjecutar)->info == NULL) &&
				(*listaPedidos) != NULL && (*listaPedidos)->info != NULL)
		{
			*contadorEjecutar = 10;
			*agregadosEjecutar = 0;

			RellenarListaEjecucion(listaPedidos,listaEjecutar,agregadosEjecutar,estoySincronizado,listaSincro);

		}*/
		///////LAB


		/* else if (*contSincro == (datosConfig.c * datosConfig.s))
		{
			*contadorEjecutar = 10;
			*agregadosEjecutar = 0;
			//liberarListaPedidos(listaEjecutar);
		}*/

	}


	if(*contSincro == (datosConfig.c * datosConfig.s))
	{
		printf("saca dudas %ld",pedido->sector);
		paq = serializarNipcSinPayload(SINCROCOMPLETA,0);
		send(socketRaid,paq,sizeof(PAQUETE_NIPC_CABECERA),0);
		free(paq);

		liberarListaSincro (listaSincro);

		estoySincronizado =0;
		*contSincro = 0;

	}


	if(*contSincro == (datosConfig.c * datosConfig.s / 2))
	{
		//printf("saca dudas %ld",pedido->sector);
		paq = serializarNipcSinPayload(SINCROSEMICOMPLETA,0);
		send(socketRaid,paq,sizeof(PAQUETE_NIPC_CABECERA),0);
		free(paq);

	}




	if(pedido->tipoOperacion == TRACE)
	{
		free(pedido);
		if(strncmp((*algoritmo),"SSTF",4) == 0)
		{
			if((*listaPedidos) != NULL && (*listaPedidos)->info != NULL)
			{
				pedido = proximoPedidoSSTF(listaPedidos,posicionActual,datosConfig);
				chs *proxSector = malloc(sizeof(chs));
				obtenerCHSDif(pedido->sector,datosConfig,proxSector);

				sprintf(auxiliar,"Proximo Sector: %u:%u \n\n",proxSector->c,proxSector->s);
				free(proxSector);
			}
			else
			{
				strcpy(auxiliar,"Proximo Sector: ...");
			}
		}
		else //n-step-scan
		{
			if((*listaEjecutar) != NULL && (*listaEjecutar)->info != NULL)
			{
				pedido = proximoPedidoNSTEP(listaEjecutar,posicionActual,datosConfig,sentidoGiro);
				chs *proxSector = malloc(sizeof(chs));
				obtenerCHSDif(pedido->sector,datosConfig,proxSector);

				sprintf(auxiliar,"Proximo Sector: %u:%u \n\n",proxSector->c,proxSector->s);
				free(proxSector);
			}
			else
			{
				strcpy(auxiliar,"Proximo Sector: ...");
			}

		}
		strcat(conversion,auxiliar);
		strcat(conversion,"\0");
		payloadlength = strlen(conversion) + 1;
		paq = serializarNipc(consolaTRACE,conversion,payloadlength);
		send(socketTrace,paq,sizeof(PAQUETE_NIPC_CABECERA) + payloadlength,0);

		free(auxiliar);
		free(paq);
		free(conversion);

	}else
	{
		free(pedido);
	}
	return 1;
}




void sacarNodoListaPedidos (stPedido *pedido,stNodoPedido **listaPedidos)
{
	stNodoPedido *aux,*borrar,*anterior;

	if ((*listaPedidos)!= NULL && (*listaPedidos)->info->sector == pedido->sector &&
			 (*listaPedidos)->info->tipoOperacion == pedido->tipoOperacion)
	{
		borrar = (*listaPedidos);
		(*listaPedidos) = (*listaPedidos)->sgte;

 		free(borrar);
		return;
	}

	aux = (*listaPedidos);

	while(aux != NULL && aux->info != NULL)
	{
		anterior = aux;
		aux = aux->sgte;
		if(aux->info->sector == pedido->sector &&
				aux->info->tipoOperacion == pedido->tipoOperacion)
		{
			borrar = aux;
			anterior->sgte = aux->sgte;
			break;
		}
	}
	//free(aux); TODO: SI FALLA POR MEMORIA VER ACA
	free(borrar);
}





void atenderPedidos(void *arg)
{

	stDatosHilo *datosHilo = (stDatosHilo *)arg;


	while(1)
	{

		sem_wait(datosHilo->semaforoContador);

		if (strncmp((*datosHilo->algoritmo),"SSTF",4) == 0)
		{
			//printf("blockea 1 \n");
			pthread_mutex_lock(datosHilo->semaforo);

			if((*datosHilo->listaPedidos) != NULL && (*datosHilo->listaPedidos)->info != NULL)
			{
				ejecutarPedido(datosHilo->algoritmo,datosHilo->pathFatFile,
						datosHilo->listaPedidos,datosHilo->datosConfig,
						datosHilo->posicionActual,datosHilo->delayLectura,
						datosHilo->delayEscritura,datosHilo->socketRaid,
						datosHilo->listaSincro,&datosHilo->contSincro,
						datosHilo->estoySincronizado,&datosHilo->contadorEjecutar,
						&datosHilo->agregadosEjecutar,datosHilo->listaEjecutar
						,&datosHilo->sentidoGiro,datosHilo->semaforoContador,
						datosHilo->hayQueLoguear);

			}

			pthread_mutex_unlock(datosHilo->semaforo);
			//printf("DESblockea 1 \n");
		}
		else
		{

			pthread_mutex_lock(datosHilo->semaforo);

			/*if(((*datosHilo->listaEjecutar)==NULL || (*datosHilo->listaEjecutar)->info == NULL) &&
							(*datosHilo->listaPedidos) != NULL && (*datosHilo->listaPedidos)->info != NULL)
			{
				datosHilo->contadorEjecutar = 10;
				datosHilo->agregadosEjecutar = 0;

				RellenarListaEjecucion(datosHilo->listaPedidos,datosHilo->listaEjecutar,&datosHilo->agregadosEjecutar,datosHilo->estoySincronizado,datosHilo->listaSincro);

			}*/


			if(datosHilo->contadorEjecutar > 0 &&
				(*datosHilo->listaEjecutar) != NULL && (*datosHilo->listaEjecutar)->info != NULL)
			{
				ejecutarPedido(datosHilo->algoritmo,datosHilo->pathFatFile,
						datosHilo->listaPedidos,datosHilo->datosConfig,
						datosHilo->posicionActual,datosHilo->delayLectura,
						datosHilo->delayEscritura,datosHilo->socketRaid,
						datosHilo->listaSincro,&datosHilo->contSincro,
						datosHilo->estoySincronizado,&datosHilo->contadorEjecutar,
						&datosHilo->agregadosEjecutar,datosHilo->listaEjecutar
						,&datosHilo->sentidoGiro,datosHilo->semaforoContador,
						datosHilo->hayQueLoguear);


			}
			pthread_mutex_unlock(datosHilo->semaforo);
		}
	}
}


void RellenarListaEjecucion(stNodoPedido **listaPedidos,stNodoPedido **listaEjecutar,
							int32_t *agregadosEjecutar, int32_t estoySincronizado,
							stNodoSincro **listaSincro,
							sem_t *semaforoContador)
{
	stNodoPedido *nuevo,*ptr;
	while(*agregadosEjecutar < 10 && (*listaPedidos) != NULL && (*listaPedidos)->info != NULL)
	{

		nuevo = (*listaPedidos);
		(*listaPedidos) = (*listaPedidos)->sgte;
		/*if((estoySincronizado == 0) &&
			(nuevo->info->tipoOperacion != ESCRIBIR ||
			 buscarSectorListaSincro(nuevo->info,listaSincro)!=0))
			*/
		if(estoySincronizado == 1)
		{
			if ((nuevo->info->tipoOperacion !=ESCRIBIR) ||
				(nuevo->info->tipoOperacion ==ESCRIBIR &&
				 buscarSectorListaSincro(nuevo->info,listaSincro)== 1))

			{

				nuevo->sgte = NULL;

				if((*listaEjecutar) != NULL && (*listaEjecutar)->info != NULL){
					for(ptr = *listaEjecutar; ptr->sgte; ptr=ptr->sgte );
					ptr->sgte = nuevo;
				}else
				{
					(*listaEjecutar)=nuevo;
				}
				//printf("RELLENAR pedido %ld",nuevo->info->sector);
				*agregadosEjecutar = *agregadosEjecutar +1;
				sem_post(semaforoContador);
			}
		}
		else
		{
			nuevo->sgte = NULL;

				if((*listaEjecutar) != NULL && (*listaEjecutar)->info != NULL){
					for(ptr = *listaEjecutar; ptr->sgte; ptr=ptr->sgte );
					ptr->sgte = nuevo;
				}else
				{
					(*listaEjecutar)=nuevo;
				}
				*agregadosEjecutar = *agregadosEjecutar +1;
				sem_post(semaforoContador);
		}


	}
}


float obtenerSeekTime(float rpm,float sectoresTotales)
{
	return (float)(60000 /(rpm*sectoresTotales));

}

void liberarListaSincro (stNodoSincro **listaSincro)
{
	stNodoSincro *borrar;


	while( (*listaSincro) &&  (*listaSincro)->sector)
	{
		borrar =  (*listaSincro);
		 (*listaSincro) =  (*listaSincro)->sgte;

		free(borrar);
	}
}


void liberarListaPedidos (stNodoPedido **listaPedidos)
{
	stNodoPedido *borrar;


	while( (*listaPedidos) &&  (*listaPedidos)->info)
	{
		borrar =  (*listaPedidos);
		 (*listaPedidos) =  (*listaPedidos)->sgte;

		free(borrar);
	}
}


char* recorroListaPedidosSSTF(stNodoPedido **listaPedidos,chs datosConfig)
{
	int32_t contador = 0;
	chs *chsPedido = malloc(sizeof(chs));
	char* resultado = (char*)malloc(sizeof(char)*80000);
	char* conversion = malloc(30);

	strcpy(resultado,"\n Cola de Pedidos: [");
	stNodoPedido *aux = (*listaPedidos);

	while(aux &&  aux->info &&  aux->info->sector)
	{
		obtenerCHSDif(aux->info->sector,datosConfig,chsPedido);
		sprintf(conversion,"%u:%u,",chsPedido->c,chsPedido->s);
		strcat(resultado,conversion);

		aux =  aux->sgte;
		contador++;
	}

	sprintf(conversion,"] Tamanio: %d\n",contador);
	strcat(resultado,conversion);
	free(conversion);

	return resultado;
}

char* recorroListaPedidosNSTEP(stNodoPedido **listaEjecutar,stNodoPedido **listaPedidos,chs datosConfig)
{
	int32_t contador = 0;
	chs *chsPedido = malloc(sizeof(chs));
	char* resultado = (char*)malloc(sizeof(char)*80000);
	char* conversion = malloc(30);

	strcpy(resultado,"\n Cola de Pedidos: [");
	stNodoPedido *aux = (*listaEjecutar);

	while(aux &&  aux->info &&  aux->info->sector)
	{
		obtenerCHSDif(aux->info->sector,datosConfig,chsPedido);
		sprintf(conversion,"%u:%u,",chsPedido->c,chsPedido->s);
		strcat(resultado,conversion);

		aux =  aux->sgte;
		contador++;
	}

	aux = (*listaPedidos);

	while(aux &&  aux->info &&  aux->info->sector)
	{
		obtenerCHSDif(aux->info->sector,datosConfig,chsPedido);
		sprintf(conversion,"%u:%u,",chsPedido->c,chsPedido->s);
		strcat(resultado,conversion);

		aux =  aux->sgte;
		contador++;
	}

	sprintf(conversion,"] Tamanio: %d\n",contador);
	strcat(resultado,conversion);
	free(conversion);

	return resultado;
}

void loguearSSTF (stPedido *pedido,stNodoPedido **listaPedidos,chs datosConfig,
					chs **posicionActual)
{
	char *logmsj =recorroListaPedidosSSTF(listaPedidos,datosConfig);
	chs *obt = malloc(sizeof(chs));
	obtenerCHSDif(pedido->sector,datosConfig,obt);

	int16_t secRecorridos =  (obt->s - (*posicionActual)->s);

	if( secRecorridos < 0)
	{
		secRecorridos =  secRecorridos + datosConfig.s;
	}

	float time = datosConfig.seekTime*secRecorridos;

	char*conversion=malloc(2000);
	sprintf(conversion,"Posicion Actual: %u:%u \n Sector solicitado: %u:%u\n Tiempo consumido: %f\n Sectores recorridos:",
			(*posicionActual)->c,(*posicionActual)->s,
			obt->c,obt->s,time);

	strcat(logmsj,conversion);


	char *auxiliar = (char*)malloc(5);
	int32_t i =(*posicionActual)->s + 1;
	for(;i<=datosConfig.s;i++)
	{
		 if(i == datosConfig.s)
		 {
			i = 0;
		 }
		 if( ((*posicionActual)->s == obt->s)|| (i == obt->s))
		 {
			 break;
		 }
		 sprintf(auxiliar,"%u:%u,",obt->c,i);
		 strcat(logmsj,auxiliar);
	}
	sprintf(auxiliar,"%u:%u",obt->c,obt->s);
	strcat(logmsj,auxiliar);
	strcat(logmsj,"\n");

	stPedido *proxPed;

	if ((*listaPedidos) != NULL && (*listaPedidos)->info != NULL )
	{
		proxPed = proximoPedidoSSTFConOmision(listaPedidos,posicionActual,
				datosConfig,pedido);
		obtenerCHSDif(proxPed->sector,datosConfig,obt);
		sprintf(conversion,"Proximo pedido: %u:%u \n",obt->c,obt->s);

	}
	else
	{
		strcpy(conversion,"Proximo pedido: ...\n");
	}
	strcat(logmsj,conversion);




	free(auxiliar);
	free(conversion);
	free(obt);
	logMessage("peticion procesada",0,0,0, logmsj,1);
	free(logmsj);
}

void loguearNSTEPSCAN (stPedido *pedido,stNodoPedido **listaEjecutar,chs datosConfig,
					chs **posicionActual, int32_t *sentidoGiro,stNodoPedido **listaPedidos)
{
	char *logmsj =recorroListaPedidosNSTEP(listaEjecutar,listaPedidos,datosConfig);
	chs *obt = malloc(sizeof(chs));
	obtenerCHSDif(pedido->sector,datosConfig,obt);

	int16_t secRecorridos =  (obt->s - (*posicionActual)->s);

	if( secRecorridos < 0)
	{
		secRecorridos =  secRecorridos + datosConfig.s;
	}

	float time = datosConfig.seekTime*secRecorridos;

	char*conversion=malloc(2000);
	sprintf(conversion,"Posicion Actual: %u:%u \n Sector solicitado: %u:%u\n Tiempo consumido: %f\n Sectores recorridos:",
			(*posicionActual)->c,(*posicionActual)->s,
			obt->c,obt->s,time);

	strcat(logmsj,conversion);


	char *auxiliar = (char*)malloc(5);
	int32_t i =(*posicionActual)->s + 1;
	for(;i<=datosConfig.s;i++)
	{
		 if(i == datosConfig.s)
		 {
			i = 0;
		 }
		 if( ((*posicionActual)->s == obt->s)|| (i == obt->s))
		 {
			 break;
		 }
		 sprintf(auxiliar,"%u:%u,",obt->c,i);
		 strcat(logmsj,auxiliar);
	}
	sprintf(auxiliar,"%u:%u",obt->c,obt->s);
	strcat(logmsj,auxiliar);
	strcat(logmsj,"\n");

	stPedido *proxPed;

	if ((*listaEjecutar) != NULL && (*listaEjecutar)->info != NULL )
	{
		proxPed = proximoPedidoNSTEPConOmision(listaEjecutar,posicionActual,
				datosConfig,sentidoGiro,pedido);
		obtenerCHSDif(proxPed->sector,datosConfig,obt);
		sprintf(conversion,"Proximo pedido: %u:%u \n",obt->c,obt->s);

	}
	else
	{
		strcpy(conversion,"Proximo pedido: ...\n");
	}
	strcat(logmsj,conversion);




	free(auxiliar);
	free(conversion);
	free(obt);
	logMessage("peticion procesada",0,0,0, logmsj,1);
	free(logmsj);
}










